home *** CD-ROM | disk | FTP | other *** search
/ Workbench Design / WB Collection.iso / workbench werkzeuge / icon tools / forceicon / source / forceicon.c < prev    next >
C/C++ Source or Header  |  1996-04-07  |  39KB  |  1,469 lines
  1. /*
  2. Auto:        smake    ForceIcon
  3. */
  4.  
  5. /* $Revision Header built automatically *************** (do not edit) ************
  6. **
  7. ** © Copyright by GuntherSoft
  8. **
  9. ** File             : SnakeSYS:CPrgs/Utils/ForceIcon.c
  10. ** Created on       : Wednesday, 20.10.93 15:55:50
  11. ** Created by       : Kai Iske
  12. ** Current revision : V1.0
  13. **
  14. **
  15. ** Purpose
  16. ** -------
  17. **   - Forces Disk Icons to a specified position.
  18. **     Usefull for CD-Rom users
  19. **
  20. ** Revision V1.0
  21. ** --------------
  22. ** created on Wednesday, 20.10.93 15:55:50  by  Kai Iske.   LogMessage :
  23. **     --- Initial release ---
  24. **
  25. *********************************************************************************/
  26.  
  27.  
  28. /**********************************************************************/
  29. /*                      Routines for this module                      */
  30. /**********************************************************************/
  31. static struct    FIconSema        *FindFIconSema(void);
  32. static void                RemoveFIconSema(struct FIconSema *FIconSema);
  33. static ULONG    __asm            DoForce(register __a0 UBYTE *Name, register __a1 struct DiskObject *DObj, register __a2 struct FreeList *FList, register __a6 struct Library *IconBase);
  34. static BOOL                StoreIconPos(struct DiskObject *Icon);
  35. static BOOL                OpenAll(void);
  36. static void                CloseAll(void);
  37.  
  38.     // The patches themselves
  39.  
  40. static ULONG    __saveds __asm        MyGetIcon(register __a0 UBYTE *Name, register __a1 struct DiskObject *DObj, register __a2 struct FreeList *FList, register __a6 struct Library *IconBase);
  41. static ULONG    __saveds __asm        MyPutIcon(register __a0 UBYTE *Name, register __a1 struct DiskObject *DObj, register __a6 struct Library *IconBase);
  42. static ULONG    __saveds __asm        MyLock(register __d1 UBYTE *Name, register __d2 ULONG Mode, register __a6 struct DosLibrary *DOSBase);
  43. static ULONG    __saveds __asm        MyRemoveAppIcon(register __a0 struct AppIcon *AIcon, register __a6 struct Library *WorkbenchBase);
  44.        ULONG    __saveds __asm        MyAddAppIconA(register __d0 ULONG ID, register __d1 ULONG UserData, register __a0 char *Text, register __a1 struct MsgPort *Port, register __a2 struct FileLock *FLock, register __a3 struct DiskObject *DObj, register __a4 struct TagItem *TagList, register __a6 struct Library *WorkbenchBase);
  45.        ULONG    __saveds __stdargs    MyAddAppIconAFunc(ULONG ID, ULONG UserData, char *Text, struct MsgPort *Port, struct FileLock *FLock, struct DiskObject *DObj, struct TagItem *TagList, struct Library *WorkbenchBase);
  46.  
  47.  
  48.  
  49.  
  50. /**********************************************************************/
  51. /*                    Functions of files included                     */
  52. /**********************************************************************/
  53.     // LoadPrefs.h
  54.  
  55. static BOOL            LoadPrefs(struct FIconSema *FIconSema, char *TryName);
  56.  
  57.     // VolList.h
  58.  
  59. static BOOL            GetDevVolList(struct List *VolList);
  60. static BOOL            GetDosEntries(struct List *VolList, ULONG Mode);
  61. static void            FreeDevVolList(struct List *VolList);
  62. static void            SortList(struct List *VolList, BOOL DisplayType);
  63. static void            SortPartialList(struct List *VolList, UWORD Left, UWORD Right);
  64. static APTR            GetListEntry(struct List *List, WORD EntryNum);
  65. static BOOL            MyStrCmp(char *FromName, char *ToName);
  66.  
  67.     // Error.h
  68.  
  69. static BOOL    __stdargs    DisplayError(LONG ErrCode, ULONG Arg1, ...);
  70.  
  71.     // PoolVec.h
  72.  
  73. static APTR            AllocVecPool(struct FIconSema *FIconSema, ULONG Size);
  74. static void            FreeVecPool(struct FIconSema *FIconSema, APTR Addr);
  75.  
  76.     // CheckToolTypes.h
  77.  
  78. static void            CheckToolTypes(struct WBStartup *WBenchMsg);
  79.  
  80.  
  81.  
  82.  
  83. /**********************************************************************/
  84. /*                           Library bases                            */
  85. /**********************************************************************/
  86. struct    ExecBase        *SysBase;
  87. struct    IntuitionBase        *IntuitionBase    = NULL;
  88. struct    DosLibrary        *DOSBase    = NULL;
  89. struct    Library            *IconBase    = NULL;
  90. struct    Library            *UtilityBase    = NULL;
  91. struct    Library            *IFFParseBase    = NULL;
  92. struct    Library            *WorkbenchBase    = NULL;
  93.  
  94.  
  95.  
  96.  
  97.  
  98.  
  99. /**********************************************************************/
  100. /*                         "No-StartUp vars"                          */
  101. /**********************************************************************/
  102. static const char        _VER[]        = "\0$VER: ForceIcon "REVISION" ("REVDATE")\0";
  103. char                _ProgramName[]    = "ForceIcon";
  104. LONG                _OSERR        = 0;
  105.  
  106.  
  107.  
  108.  
  109.  
  110. /**********************************************************************/
  111. /*                           Our variables                            */
  112. /**********************************************************************/
  113. static    ULONG    __asm        (*OldGetIcon)(register __a0 UBYTE *, register __a1 struct DiskObject *, register __a2 struct FreeList *, register __a6 struct Library *);
  114. static    ULONG    __asm        (*OldPutIcon)(register __a0 UBYTE *, register __a1 struct DiskObject *, register __a6 struct Library *);
  115. static    ULONG    __asm        (*OldLock)(register __d1 UBYTE *, register __d2 ULONG, register __a6 struct DosLibrary *);
  116. static    ULONG    __asm        (*OldRemoveAppIcon)(register __a0 struct AppIcon *, register __a6 struct Library *);
  117.     ULONG    __asm        (*OldAddAppIconA)(register __d0 ULONG, register __d1 ULONG, register __a0 char *, register __a1 struct MsgPort *, register __a2 struct FileLock *, register __a3 struct DiskObject *, register __a4 struct TagItem *, register __a6 struct Library *);
  118.  
  119. static    struct    FIconSema    *FIconSema    = NULL;        // Pointer to our rendezvous semaphore
  120. static    LONG            SnapNotify    = 2;        // How to notify a snap
  121. static    ULONG            NumAppIcons    = 0;        // Number of AppIcons patched
  122.  
  123.  
  124.  
  125.  
  126.  
  127.  
  128. /**********************************************************************/
  129. /*                      This is our main program                      */
  130. /**********************************************************************/
  131. ULONG __saveds main(void)
  132. {
  133.     struct    Process        *MyProc;
  134.     struct    WBStartup    *WBenchMsg    = NULL;
  135.     BOOL            QuitIT        = FALSE;
  136.  
  137.  
  138.  
  139.         // Get SysBase
  140.  
  141.     SysBase    = *((struct ExecBase **)0x4L);
  142.  
  143.  
  144.         // Get address of our process
  145.  
  146.     MyProc = (struct Process *)FindTask(NULL);
  147.  
  148.  
  149.  
  150.         // Determine where we were started from
  151.  
  152.     if(!MyProc->pr_CLI)
  153.     {
  154.         WaitPort(&MyProc->pr_MsgPort);
  155.         WBenchMsg = (struct WBStartup *)GetMsg(&MyProc->pr_MsgPort);
  156.     }
  157.  
  158.  
  159.  
  160.         // Don`t run under OS < 37
  161.  
  162.     if(((struct Library *)SysBase)->lib_Version >= 37)
  163.     {
  164.             // Open libraries
  165.  
  166.         if(OpenAll())
  167.         {
  168.                 // Prefs Program there ???
  169.  
  170.             if((FIconSema = FindFIconSema()))
  171.             {
  172.  
  173.                     // Check ToolTypes
  174.  
  175.                 CheckToolTypes(WBenchMsg);
  176.  
  177.  
  178.                 Disable();
  179.                     // Patch icon.library functions
  180.  
  181.                 OldGetIcon        = (ULONG *)SetFunction(IconBase, -0x0000002a, &MyGetIcon);
  182.                 OldPutIcon        = (ULONG *)SetFunction(IconBase, -0x00000030, &MyPutIcon);
  183.  
  184.                     // Patch dos.library functions
  185.  
  186.                 OldLock            = (ULONG *)SetFunction(DOSBase, -0x00000054, &MyLock);
  187.  
  188.                     // Patch workbench.library functions
  189.  
  190.                 OldAddAppIconA        = (ULONG *)SetFunction(WorkbenchBase, -0x0000003c, &MyAddAppIconA);
  191.                 OldRemoveAppIcon    = (ULONG *)SetFunction(WorkbenchBase, -0x00000042, &MyRemoveAppIcon);
  192.  
  193.                 Enable();
  194.  
  195.  
  196.  
  197.                     // Ok, patches placed.
  198.                     // Make all connected drives diskchange
  199.  
  200.                 {
  201.                     struct    List    ChangeList;
  202.  
  203.                     ObtainSemaphore(&FIconSema->FIconSema);
  204.  
  205.                     NewList(&ChangeList);
  206.  
  207.                         // Create list of connected devices
  208.  
  209.                     if(GetDosEntries(&ChangeList, LDF_VOLUMES))
  210.                     {
  211.                         struct    DosList        *DList;
  212.                         struct    VolEntry    *ThisEntry,
  213.                                     *ListEntry;
  214.                         struct    DevProc        *DevProc;
  215.                         char            DevName[130];
  216.                         BOOL            FoundDev,
  217.                                     DoDskCh;
  218.  
  219.                         while((ThisEntry = (struct VolEntry *)RemHead(&ChangeList)))
  220.                         {
  221.                             FoundDev    = FALSE;
  222.                             DoDskCh        = FALSE;
  223.  
  224.                                 // Find name of device this volume resides in
  225.  
  226.                             if((DList = LockDosList(LDF_DEVICES|LDF_READ)))
  227.                             {
  228.                                 while((DList = NextDosEntry(DList, LDF_DEVICES|LDF_READ)))
  229.                                 {
  230.                                     if(ThisEntry->DriverTask == DList->dol_Task && !FoundDev)
  231.                                     {
  232.                                         setmem(DevName, 130, 0);
  233.                                         strncpy(DevName, ((char *)BADDR(DList->dol_Name) + 1), *((char *)BADDR(DList->dol_Name)));
  234.                                         FoundDev    = TRUE;
  235.                                     }
  236.                                 }
  237.                                 UnLockDosList(LDF_DEVICES|LDF_READ);
  238.                             }
  239.  
  240.                                 // Found corresponding device ???
  241.  
  242.                             if(FoundDev)
  243.                             {
  244.                                     // Check whether to diskchange
  245.  
  246.                                 ListEntry    = (struct VolEntry *)FIconSema->VolumeList.lh_Head;
  247.                                 while(ListEntry->Link.ln_Succ && !DoDskCh)
  248.                                 {
  249.                                     if(ListEntry->Link.ln_Type == LDF_DEVICES)
  250.                                         DoDskCh    = (MyStrCmp(ListEntry->VolName, DevName) == 0);
  251.                                     else
  252.                                         DoDskCh    = (MyStrCmp(ListEntry->VolName, ThisEntry->VolName) == 0);
  253.  
  254.                                     ListEntry = (struct VolEntry *)ListEntry->Link.ln_Succ;
  255.                                 }
  256.  
  257.                                 if(DoDskCh)
  258.                                 {
  259.                                     strcat(DevName, ":");
  260.  
  261.                                     if(ThisEntry->DriverTask && (DevProc = GetDeviceProc(DevName, NULL)))
  262.                                     {
  263.                                         if(TypeOfMem(DevProc->dvp_Port))
  264.                                         {
  265.                                             if(DoPkt(DevProc->dvp_Port, ACTION_INHIBIT, DOSTRUE, NULL, NULL, NULL, NULL))
  266.                                                 DoPkt(DevProc->dvp_Port, ACTION_INHIBIT, DOSFALSE, NULL, NULL, NULL, NULL);
  267.                                         }
  268.                                         FreeDeviceProc(DevProc);
  269.                                     }
  270.                                 }
  271.                             }
  272.  
  273.                             FreeVecPool(FIconSema, ThisEntry);
  274.                         }
  275.                     }
  276.  
  277.                     ReleaseSemaphore(&FIconSema->FIconSema);
  278.                 }
  279.  
  280.                     // Wait for termination
  281.  
  282.                 while(!QuitIT)
  283.                 {
  284.                     ULONG    MySig;
  285.  
  286.                     MySig    = Wait(SIGBREAKF_CTRL_C|SIGBREAKF_CTRL_D);
  287.  
  288.                         // User snapped icon?
  289.  
  290.                     if(MySig & SIGBREAKF_CTRL_D)
  291.                     {
  292.                         if(FIconSema->PrefsTask)
  293.                             Signal(FIconSema->PrefsTask, SIGBREAKF_CTRL_F);
  294.  
  295.                         if(SnapNotify == 2)
  296.                             DisplayError(ERR_SNAPEDICON, NULL);
  297.                         else if(SnapNotify == 1)
  298.                             DisplayBeep(NULL);
  299.                     }
  300.                     else
  301.                     {
  302.                         BOOL    DoCheckQuit    = TRUE;
  303.  
  304.                         if(NumAppIcons)
  305.                             DoCheckQuit    = DisplayError(ERR_APPICONSPATCHED, NumAppIcons, NULL);
  306.  
  307.                         if(DoCheckQuit)
  308.                         {
  309.                             APTR        CheckGetIcon,
  310.                                     CheckPutIcon,
  311.                                     CheckLock,
  312.                                     CheckAddAppIconA,
  313.                                     CheckRemoveAppIcon;
  314.  
  315.  
  316.                                 // Ok, we are to quit
  317.  
  318.                             QuitIT    = TRUE;
  319.  
  320.  
  321.                             Disable();
  322.  
  323.                                 // Try to re-install old vectors
  324.  
  325.                             CheckGetIcon        = SetFunction(IconBase, -0x0000002a, OldGetIcon);
  326.                             CheckPutIcon        = SetFunction(IconBase, -0x00000030, OldPutIcon);
  327.                             CheckLock        = SetFunction(DOSBase, -0x00000054, OldLock);
  328.                             CheckAddAppIconA    = (ULONG *)SetFunction(WorkbenchBase, -0x0000003c, OldAddAppIconA);
  329.                             CheckRemoveAppIcon    = (ULONG *)SetFunction(WorkbenchBase, -0x00000042, OldRemoveAppIcon);
  330.  
  331.                             if((CheckGetIcon != (APTR)&MyGetIcon) || (CheckPutIcon != (APTR)&MyPutIcon) || (CheckLock != (APTR)&MyLock) || (CheckAddAppIconA != (APTR)&MyAddAppIconA) || (CheckRemoveAppIcon != (APTR)&MyRemoveAppIcon))
  332.                             {
  333.                                 QuitIT = FALSE;
  334.  
  335.                                     // Re-install patches created by someone else
  336.  
  337.                                 SetFunction(IconBase, -0x0000002a, CheckGetIcon);
  338.                                 SetFunction(IconBase, -0x00000030, CheckPutIcon);
  339.                                 SetFunction(DOSBase, -0x00000054, CheckLock);
  340.                                 SetFunction(WorkbenchBase, -0x0000003c, CheckAddAppIconA);
  341.                                 SetFunction(WorkbenchBase, -0x00000042, CheckRemoveAppIcon);
  342.                             }
  343.  
  344.                             Enable();
  345.  
  346.                             if(!QuitIT)
  347.                             {
  348.                                 if(CheckGetIcon != (APTR)&MyGetIcon)
  349.                                     DisplayError(ERR_PATCH, (ULONG)"GetIcon()", NULL);
  350.                                 else if(CheckPutIcon != (APTR)&MyPutIcon)
  351.                                     DisplayError(ERR_PATCH, (ULONG)"PutIcon()", NULL);
  352.                                 else if(CheckLock != (APTR)&MyLock)
  353.                                     DisplayError(ERR_PATCH, (ULONG)"Lock()", NULL);
  354.                                 else if(CheckAddAppIconA != (APTR)&MyAddAppIconA)
  355.                                     DisplayError(ERR_PATCH, (ULONG)"AddAppIconA()", NULL);
  356.                                 else if(CheckRemoveAppIcon != (APTR)&MyRemoveAppIcon)
  357.                                     DisplayError(ERR_PATCH, (ULONG)"RemoveAppIcon()", NULL);
  358.  
  359.                             }
  360.                         }
  361.                     }
  362.                 }
  363.             }
  364.             RemoveFIconSema(FIconSema);
  365.         }
  366.     }
  367.  
  368.  
  369.         // Close libs
  370.  
  371.     CloseAll();
  372.  
  373.  
  374.         // Send back WBStartUp Message
  375.  
  376.     if(WBenchMsg)
  377.     {
  378.         Forbid();
  379.         ReplyMsg((struct Message *)WBenchMsg);
  380.     }
  381.     return(0);
  382. }
  383.  
  384.  
  385.  
  386.  
  387. /**********************************************************************/
  388. /*                        Functionreplacements                        */
  389. /**********************************************************************/
  390. void chkabort(void){;}
  391. void __stdargs _XCEXIT(LONG Val){;}
  392.  
  393.  
  394.  
  395.  
  396.  
  397. /**********************************************************************/
  398. /*                      My new GetIcon function                       */
  399. /**********************************************************************/
  400. static ULONG __saveds __asm MyGetIcon(register __a0 UBYTE *Name, register __a1 struct DiskObject *DObj, register __a2 struct FreeList *FList, register __a6 struct Library *IconBase)
  401. {
  402.     struct    Process        *MyProc = (struct Process *)FindTask(NULL);
  403.     ULONG    RetVal;
  404.  
  405.         // Calling process a real process and is it Workbench ?
  406.  
  407.     if((MyProc->pr_Task.tc_Node.ln_Type == NT_PROCESS) && !strcmp(MyProc->pr_Task.tc_Node.ln_Name, "Workbench"))
  408.     {
  409.             if(!stricmp(Name, "Disk"))
  410.                 RetVal = DoForce(Name, DObj, FList, IconBase);
  411.             else
  412.                 RetVal = OldGetIcon(Name, DObj, FList, IconBase);
  413.     }
  414.     else
  415.         RetVal = OldGetIcon(Name, DObj, FList, IconBase);
  416.  
  417.     return(RetVal);
  418. }
  419.  
  420.  
  421.  
  422.  
  423. /**********************************************************************/
  424. /*                      My new PutIcon function                       */
  425. /**********************************************************************/
  426. static ULONG __saveds __asm MyPutIcon(register __a0 UBYTE *Name, register __a1 struct DiskObject *DObj, register __a6 struct Library *IconBase)
  427. {
  428.     struct    Process        *MyProc = (struct Process *)FindTask(NULL);
  429.     ULONG    RetVal;
  430.  
  431.         // Calling process a real process and is it Workbench ?
  432.  
  433.     if((MyProc->pr_Task.tc_Node.ln_Type == NT_PROCESS) && !strcmp(MyProc->pr_Task.tc_Node.ln_Name, "Workbench"))
  434.     {
  435.             if(!stricmp(Name, "Disk"))
  436.             {
  437.                 if(!StoreIconPos(DObj))
  438.                     RetVal    = OldPutIcon(Name, DObj, IconBase);
  439.                 else
  440.                 {
  441.                     Signal(FIconSema->ServerTask, SIGBREAKF_CTRL_D);
  442.                     RetVal    = TRUE;
  443.                 }
  444.             }
  445.             else
  446.                 RetVal = OldPutIcon(Name, DObj, IconBase);
  447.     }
  448.     else
  449.         RetVal = OldPutIcon(Name, DObj, IconBase);
  450.  
  451.     return(RetVal);
  452. }
  453.  
  454.  
  455.  
  456.  
  457.  
  458. /**********************************************************************/
  459. /*                       Main forcement routine                       */
  460. /**********************************************************************/
  461. static ULONG __asm DoForce(register __a0 UBYTE *Name, register __a1 struct DiskObject *DObj, register __a2 struct FreeList *FList, register __a6 struct Library *IconBase)
  462. {
  463.     struct    FileLock    *Dir;
  464.     struct    DosList        *DList;
  465.     char            *VolName,
  466.                 *DevName    = NULL,
  467.                 *IconName;
  468.     BPTR            MyLock,
  469.                 CheckLock;
  470.     LONG            Left,
  471.                 Top,
  472.                 WinWidth,
  473.                 WinHeight,
  474.                 WinFlags;
  475.     WORD            WinX,
  476.                 WinY;
  477.     ULONG            RetVal        = 0;
  478.     BOOL            Found        = FALSE,
  479.                 UseAltIcon,
  480.                 UseIconPos,
  481.                 UseWindow,
  482.                 UseFlags;
  483.  
  484.  
  485.  
  486.  
  487.  
  488.         // Get our semaphore
  489.  
  490.     ObtainSemaphore(&FIconSema->FIconSema);
  491.  
  492.  
  493.         // Get buffers
  494.  
  495.     if((VolName = AllocMem(130, MEMF_CLEAR)) && (DevName = AllocMem(130, MEMF_CLEAR)))
  496.     {
  497.             // Switch to current dir
  498.  
  499.         MyLock    = CurrentDir(NULL);
  500.         Dir    = (struct FileLock *)BADDR(MyLock);
  501.         DList    = (struct DosList *)BADDR(Dir->fl_Volume);
  502.  
  503.             // Get name of volume inserted
  504.  
  505.         strncpy(VolName, ((char *)BADDR(DList->dol_Name) + 1), *((char *)BADDR(DList->dol_Name)));
  506.  
  507.             // Reset current dir
  508.  
  509.         CurrentDir(MyLock);
  510.  
  511.             // Get Name of Device
  512.  
  513.         if((DList = LockDosList(LDF_DEVICES|LDF_READ)))
  514.         {
  515.             while((DList = NextDosEntry(DList, LDF_DEVICES|LDF_READ)))
  516.             {
  517.                 if(Dir->fl_Task == DList->dol_Task)
  518.                     strncpy(DevName, ((char *)BADDR(DList->dol_Name) + 1), *((char *)BADDR(DList->dol_Name)));
  519.             }
  520.             UnLockDosList(LDF_DEVICES|LDF_READ);
  521.         }
  522.  
  523.             // Really to load from ROOT ???
  524.  
  525.         if(!(CheckLock = ParentDir(MyLock)))
  526.         {
  527.                 // Do we have patches waiting ???
  528.  
  529.             if(!IsListEmpty(&FIconSema->VolumeList))
  530.             {
  531.                 struct    VolEntry    *ThisEntry = (struct VolEntry *)FIconSema->VolumeList.lh_Head;
  532.  
  533.                 do
  534.                 {
  535.                         // This one to patch ???
  536.  
  537.                     if(ThisEntry->Link.ln_Type == LDF_DEVICES && !MyStrCmp(ThisEntry->VolName, DevName))
  538.                         Found = TRUE;
  539.  
  540.                     else if(ThisEntry->Link.ln_Type == LDF_VOLUMES && !MyStrCmp(ThisEntry->VolName, VolName))
  541.                         Found = TRUE;
  542.  
  543.                     else
  544.                         ThisEntry = (struct VolEntry *)ThisEntry->Link.ln_Succ;
  545.  
  546.                 } while(!Found && ThisEntry->Link.ln_Succ);
  547.  
  548.                     // Object to be patched ?
  549.  
  550.                 if(Found)
  551.                 {
  552.                         // Set vars for icon substitution
  553.  
  554.                     UseAltIcon    = (ThisEntry->UseAlt == MODE_USE);
  555.                     IconName    = ThisEntry->IconName;
  556.  
  557.                         // Set vars for icon placement
  558.  
  559.                     UseIconPos    = (ThisEntry->IconPos == MODE_USE);
  560.                     Left        = ThisEntry->Left;
  561.                     Top        = ThisEntry->Top;
  562.  
  563.                         // Set vars for window settings
  564.  
  565.                     UseWindow    = (ThisEntry->UseWin == MODE_USE);
  566.                     WinX        = ThisEntry->WinX;
  567.                     WinY        = ThisEntry->WinY;
  568.                     WinWidth    = ThisEntry->WinWidth;
  569.                     WinHeight    = ThisEntry->WinHeight;
  570.  
  571.                         // Set vars for window flags
  572.  
  573.                     UseFlags    = (ThisEntry->UseFlags == MODE_USE);
  574.                     WinFlags    = ThisEntry->WinFlags;
  575.  
  576.  
  577.                         // This entry a volume and are we allowed to obtain settings from device ???
  578.  
  579.                     if(ThisEntry->Link.ln_Type == LDF_VOLUMES)
  580.                     {
  581.                         struct    VolEntry    *DevEntry    = (struct VolEntry *)FIconSema->VolumeList.lh_Head;
  582.                         BOOL            FoundMyDev    = FALSE;
  583.  
  584.                             // Search for device-entry corresponding to volume
  585.  
  586.                         while(DevEntry->Link.ln_Succ && !FoundMyDev)
  587.                         {
  588.                             if(DevEntry->Link.ln_Type == LDF_DEVICES && !MyStrCmp(DevEntry->VolName, DevName))
  589.                                 FoundMyDev    = TRUE;
  590.                             else
  591.                                 DevEntry    = (struct VolEntry *)DevEntry->Link.ln_Succ;
  592.                         }
  593.  
  594.                             // Got a device entry for this volume ???
  595.  
  596.                         if(FoundMyDev)
  597.                         {
  598.                                 // Use alternative icon for volume ???
  599.  
  600.                             if(ThisEntry->UseAlt == MODE_INHERIT)
  601.                             {
  602.                                     // no, use one for device entry ???
  603.                                     // If so, set pointer to new iconname
  604.  
  605.                                 if(DevEntry->UseAlt == MODE_USE)
  606.                                 {
  607.                                     UseAltIcon    = TRUE;
  608.                                     IconName    = DevEntry->IconName;
  609.                                 }
  610.                             }
  611.  
  612.                                 // Use alternative position for volume ???
  613.  
  614.                             if(ThisEntry->IconPos == MODE_INHERIT)
  615.                             {
  616.                                     // no, use one for device entry ???
  617.                                     // if so, set vars
  618.  
  619.                                 if(DevEntry->IconPos == MODE_USE)
  620.                                 {
  621.                                     UseIconPos    = TRUE;
  622.                                     Left        = DevEntry->Left;
  623.                                     Top        = DevEntry->Top;
  624.                                 }
  625.                             }
  626.  
  627.                                 // Use settings of window ???
  628.  
  629.                             if(ThisEntry->UseWin == MODE_INHERIT)
  630.                             {
  631.                                     // no, use one for device entry ???
  632.                                     // if so, set vars
  633.  
  634.                                 if(DevEntry->UseWin == MODE_USE)
  635.                                 {
  636.                                     UseWindow    = TRUE;
  637.                                     WinX        = DevEntry->WinX;
  638.                                     WinY        = DevEntry->WinY;
  639.                                     WinWidth    = DevEntry->WinWidth;
  640.                                     WinHeight    = DevEntry->WinHeight;
  641.                                 }
  642.                             }
  643.  
  644.                                 // Use settings of flags
  645.  
  646.                             if(ThisEntry->UseFlags == MODE_INHERIT)
  647.                             {
  648.                                     // no, use one for device entry ???
  649.                                     // if so, set vars
  650.  
  651.                                 if(DevEntry->UseFlags == MODE_USE)
  652.                                 {
  653.                                     UseFlags    = TRUE;
  654.                                     WinFlags    = DevEntry->WinFlags;
  655.                                 }
  656.                             }
  657.                         }
  658.                     }
  659.  
  660.  
  661.                         // Alternative icon ???
  662.  
  663.                     if(UseAltIcon)
  664.                     {
  665.                         char    *EndPtr;
  666.  
  667.                             // Check for name and remove extension
  668.  
  669.                         strcpy(VolName, IconName);
  670.                         strlwr(VolName);
  671.                         if((EndPtr = strstr(VolName, ".info")))
  672.                         {
  673.                             BPTR    TestLock;
  674.  
  675.                             setmem(VolName, 130, 0);
  676.                             strncpy(VolName, IconName, (EndPtr - VolName));
  677.  
  678.                                 // Try to get supplied name
  679.  
  680.                             if((TestLock = Lock(IconName, ACCESS_READ)))
  681.                             {
  682.                                 UnLock(TestLock);
  683.  
  684.                                     // Try to read in this icon
  685.  
  686.                                 if(!(RetVal = OldGetIcon(VolName, DObj, FList, IconBase)))
  687.                                     RetVal = OldGetIcon(Name, DObj, FList, IconBase);
  688.                                 else
  689.                                 {
  690.                                     BOOL    GotData    = FALSE;
  691.  
  692.                                         // Ok, we`ve loaded a new icon, so set appropriate flags ;)
  693.  
  694.                                     if(DObj->do_Type == WBTOOL || DObj->do_Type == WBPROJECT)
  695.                                     {
  696.                                             // Try to set drawerdata for tool and project icons
  697.  
  698.                                         if((DObj->do_DrawerData = AllocMem(sizeof(struct DrawerData), MEMF_CLEAR|MEMF_PUBLIC)))
  699.                                             GotData    = TRUE;
  700.                                     }
  701.                                     else
  702.                                         GotData = TRUE;
  703.  
  704.                                     if(GotData)
  705.                                     {
  706.                                         struct    DrawerData    *DDat = DObj->do_DrawerData;
  707.  
  708.                                             // Fill in structure
  709.  
  710.                                         DDat->dd_NewWindow.LeftEdge    = ThisEntry->LeftEdge;
  711.                                         DDat->dd_NewWindow.TopEdge    = ThisEntry->TopEdge;
  712.                                         DDat->dd_NewWindow.Width    = ThisEntry->Width;
  713.                                         DDat->dd_NewWindow.Height    = ThisEntry->Height;
  714.                                         DDat->dd_NewWindow.DetailPen    = 255;
  715.                                         DDat->dd_NewWindow.BlockPen    = 255;
  716.                                         DDat->dd_NewWindow.Flags    = WFLG_HASZOOM|WFLG_WINDOWTICKED|WFLG_REPORTMOUSE|WFLG_SIMPLE_REFRESH|WFLG_SIZEBRIGHT|WFLG_SIZEBBOTTOM|WFLG_CLOSEGADGET|WFLG_DEPTHGADGET|WFLG_DRAGBAR|WFLG_SIZEGADGET;
  717.                                         DDat->dd_NewWindow.MinWidth    = 90;
  718.                                         DDat->dd_NewWindow.MinHeight    = 40;
  719.                                         DDat->dd_NewWindow.MaxWidth    = 0xffff;
  720.                                         DDat->dd_NewWindow.MaxHeight    = 0xffff;
  721.                                         DDat->dd_NewWindow.Type        = WBENCHSCREEN;
  722.                                         DDat->dd_CurrentX        = ThisEntry->CurrentX;
  723.                                         DDat->dd_CurrentY        = ThisEntry->CurrentY;
  724.                                         DDat->dd_Flags            = ThisEntry->Flags;
  725.                                         DDat->dd_ViewModes        = ThisEntry->ViewMode;
  726.  
  727.                                             // A Ok, set new type of icon
  728.  
  729.                                         DObj->do_Type = WBDISK;
  730.                                     }
  731.                                 }
  732.                             }
  733.                             else
  734.                                 RetVal = OldGetIcon(Name, DObj, FList, IconBase);
  735.                         }
  736.                         else
  737.                             RetVal = OldGetIcon(Name, DObj, FList, IconBase);
  738.                     }
  739.                     else
  740.                         RetVal = OldGetIcon(Name, DObj, FList, IconBase);
  741.  
  742.                     if(RetVal)
  743.                     {
  744.                         struct    Screen    *WBScreen    = LockPubScreen("Workbench");
  745.  
  746.                             // Patch position ???
  747.  
  748.                         if(WBScreen)
  749.                         {
  750.                                 // Do so
  751.  
  752.                             DObj->do_CurrentX = ((UseIconPos) ? (Left < 0 ? WBScreen->Width + Left : Left) : NO_ICON_POSITION);
  753.                             DObj->do_CurrentY = ((UseIconPos) ? (Top < 0 ? WBScreen->Height + Top - WBScreen->BarHeight - 1 : Top - WBScreen->BarHeight - 1) : NO_ICON_POSITION);
  754.  
  755.                             UnlockPubScreen(NULL, WBScreen);
  756.                         }
  757.  
  758.                             // Use window ???
  759.  
  760.                         if(UseWindow)
  761.                         {
  762.                             DObj->do_DrawerData->dd_NewWindow.LeftEdge    = WinX;
  763.                             DObj->do_DrawerData->dd_NewWindow.TopEdge    = WinY;
  764.                             DObj->do_DrawerData->dd_NewWindow.Width        = WinWidth;
  765.                             DObj->do_DrawerData->dd_NewWindow.Height    = WinHeight;
  766.                         }
  767.  
  768.                             // Set Flags ???
  769.  
  770.                         if(UseFlags)
  771.                         {
  772.                             DObj->do_DrawerData->dd_Flags            = (WinFlags > 3 ? 2 : 0);
  773.                             DObj->do_DrawerData->dd_ViewModes        = (WinFlags > 3 ? WinFlags - 3 : WinFlags + 1);
  774.                         }
  775.                     }
  776.                 }
  777.             }
  778.         }
  779.         else
  780.             UnLock(CheckLock);
  781.     }
  782.  
  783.     if(VolName)
  784.         FreeMem(VolName, 130);
  785.  
  786.     if(DevName)
  787.         FreeMem(DevName, 130);
  788.  
  789.  
  790.         // No entry found and not the orig. icon read -> use supplied name
  791.  
  792.     if(!Found && !RetVal)
  793.         RetVal = OldGetIcon(Name, DObj, FList, IconBase);
  794.  
  795.         // Release that fine semaphore
  796.  
  797.     ReleaseSemaphore(&FIconSema->FIconSema);
  798.  
  799.     return(RetVal);
  800. }
  801.  
  802.  
  803.  
  804.  
  805.  
  806. /**********************************************************************/
  807. /*                        My new Lock routine                         */
  808. /**********************************************************************/
  809. static ULONG __saveds __asm MyLock(register __d1 UBYTE *Name, register __d2 ULONG Mode, register __a6 struct DosLibrary *DOSBase)
  810. {
  811.     struct    Process        *MyProc        = (struct Process *)FindTask(NULL);
  812.     struct    FileLock    *Dir;
  813.     struct    DosList        *DList;
  814.     char            *VolName,
  815.                 *DevName    = NULL,
  816.                 *IconName;
  817.     BPTR            MyLock,
  818.                 CheckLock;
  819.     ULONG            RetVal        = NULL;
  820.     BOOL            Found        = FALSE,
  821.                 UseAltIcon;
  822.  
  823.  
  824.  
  825.         // Get buffers
  826.  
  827.     if((VolName = AllocMem(130, MEMF_CLEAR|MEMF_PUBLIC)) && (DevName = AllocMem(130, MEMF_CLEAR|MEMF_PUBLIC)))
  828.     {
  829.             // Calling process a real process and is it Workbench ?
  830.  
  831.         if((MyProc->pr_Task.tc_Node.ln_Type == NT_PROCESS) && TypeOfMem(MyProc->pr_Task.tc_Node.ln_Name) && !strcmp(MyProc->pr_Task.tc_Node.ln_Name, "Workbench"))
  832.         {
  833.  
  834.                 // Trying to load a Disk.info ???
  835.  
  836.             if(TypeOfMem(Name) && !stricmp(Name, "Disk.info"))
  837.             {
  838.                     // Get my semaphore
  839.  
  840.                 ObtainSemaphore(&FIconSema->FIconSema);
  841.  
  842.                     // Switch to current dir
  843.  
  844.                 MyLock    = CurrentDir(NULL);
  845.                 Dir    = (struct FileLock *)BADDR(MyLock);
  846.                 DList    = (struct DosList *)BADDR(Dir->fl_Volume);
  847.  
  848.                     // Get name of volume inserted
  849.  
  850.                 strncpy(VolName, ((char *)BADDR(DList->dol_Name) + 1), *((char *)BADDR(DList->dol_Name)));
  851.  
  852.                     // Reset current dir
  853.  
  854.                 CurrentDir(MyLock);
  855.  
  856.                     // Get Name of Device
  857.  
  858.                 if((DList = LockDosList(LDF_DEVICES|LDF_READ)))
  859.                 {
  860.                     while((DList = NextDosEntry(DList, LDF_DEVICES|LDF_READ)))
  861.                     {
  862.                         if(Dir->fl_Task == DList->dol_Task)
  863.                             strncpy(DevName, ((char *)BADDR(DList->dol_Name) + 1), *((char *)BADDR(DList->dol_Name)));
  864.                     }
  865.                     UnLockDosList(LDF_DEVICES|LDF_READ);
  866.                 }
  867.  
  868.                     // Really load from ROOT ?
  869.  
  870.                 if(!(CheckLock = ParentDir(MyLock)))
  871.                 {
  872.                         // Do we have patches waiting ???
  873.  
  874.                     if(!IsListEmpty(&FIconSema->VolumeList))
  875.                     {
  876.                         struct    VolEntry    *ThisEntry = (struct VolEntry *)FIconSema->VolumeList.lh_Head;
  877.  
  878.                         do
  879.                         {
  880.                                 // This one to patch ???
  881.  
  882.                             if(ThisEntry->Link.ln_Type == LDF_DEVICES && !MyStrCmp(ThisEntry->VolName, DevName))
  883.                                 Found = TRUE;
  884.  
  885.                             else if(ThisEntry->Link.ln_Type == LDF_VOLUMES && !MyStrCmp(ThisEntry->VolName, VolName))
  886.                                 Found = TRUE;
  887.  
  888.                             else
  889.                                 ThisEntry = (struct VolEntry *)ThisEntry->Link.ln_Succ;
  890.  
  891.                         } while(!Found && ThisEntry->Link.ln_Succ);
  892.  
  893.                             // Object to be patched ?
  894.  
  895.                         if(Found)
  896.                         {
  897.                                 // Set vars for icon substitution
  898.  
  899.                             UseAltIcon    = (ThisEntry->UseAlt == MODE_USE);
  900.                             IconName    = ThisEntry->IconName;
  901.  
  902.                                 // This entry a volume and are we allowed to obtain settings from a device ???
  903.  
  904.                             if(ThisEntry->Link.ln_Type == LDF_VOLUMES)
  905.                             {
  906.                                 struct    VolEntry    *DevEntry    = (struct VolEntry *)FIconSema->VolumeList.lh_Head;
  907.                                 BOOL            FoundMyDev    = FALSE;
  908.  
  909.                                     // Search for device-entry corresponding to volume
  910.  
  911.                                 while(DevEntry->Link.ln_Succ && !FoundMyDev)
  912.                                 {
  913.                                     if(DevEntry->Link.ln_Type == LDF_DEVICES && !MyStrCmp(DevEntry->VolName, DevName))
  914.                                         FoundMyDev    = TRUE;
  915.                                     else
  916.                                         DevEntry    = (struct VolEntry *)DevEntry->Link.ln_Succ;
  917.                                 }
  918.  
  919.                                     // Got a device entry for this volume ???
  920.  
  921.                                 if(FoundMyDev)
  922.                                 {
  923.                                         // Use alternative icon for volume ???
  924.  
  925.                                     if(ThisEntry->UseAlt == MODE_INHERIT)
  926.                                     {
  927.                                             // no, use one for device entry ???
  928.                                             // If so, set pointer to new iconname
  929.  
  930.                                         if(DevEntry->UseAlt == MODE_USE)
  931.                                         {
  932.                                             UseAltIcon    = TRUE;
  933.                                             IconName    = DevEntry->IconName;
  934.                                         }
  935.                                     }
  936.                                 }
  937.                             }
  938.  
  939.                                 // If an alternative icon is to be used
  940.                                 // lock this one, otherwise lock Disk.info
  941.  
  942.                             if(UseAltIcon)
  943.                             {
  944.                                 struct    DiskObject    *OldDiskObject;
  945.                                 WORD    OldLeft        = 50,
  946.                                     OldTop        = 50,
  947.                                     OldWidth     = 400,
  948.                                     OldHeight    = 100;
  949.                                 LONG    OldCurrentX    = 0,
  950.                                     OldCurrentY    = 0;
  951.                                 ULONG    OldFlags    = 0x0;
  952.                                 UWORD    OldViewMode    = 1;
  953.  
  954.                                 if(!(RetVal = OldLock(IconName, Mode, DOSBase)))
  955.                                     RetVal = OldLock(Name, Mode, DOSBase);
  956.                                 else
  957.                                 {
  958.                                         // Get original Disk.info file, in order to obtain
  959.                                         // the correct window position and size
  960.  
  961.                                     strcat(DevName, ":Disk");
  962.                                     if(!(OldDiskObject = GetDiskObject(DevName)))
  963.                                     {
  964.                                         strcat(VolName, ":Disk");
  965.                                         OldDiskObject = GetDiskObject(VolName);
  966.                                     }
  967.  
  968.                                     if(OldDiskObject)
  969.                                     {
  970.                                         OldLeft        = OldDiskObject->do_DrawerData->dd_NewWindow.LeftEdge;
  971.                                         OldTop        = OldDiskObject->do_DrawerData->dd_NewWindow.TopEdge;
  972.                                         OldWidth    = OldDiskObject->do_DrawerData->dd_NewWindow.Width;
  973.                                         OldHeight    = OldDiskObject->do_DrawerData->dd_NewWindow.Height;
  974.                                         OldCurrentX    = OldDiskObject->do_DrawerData->dd_CurrentX;
  975.                                         OldCurrentY    = OldDiskObject->do_DrawerData->dd_CurrentY;
  976.                                         OldFlags    = OldDiskObject->do_DrawerData->dd_Flags;
  977.                                         OldViewMode    = OldDiskObject->do_DrawerData->dd_ViewModes;
  978.  
  979.                                         FreeDiskObject(OldDiskObject);
  980.                                     }
  981.  
  982.                                     ThisEntry->LeftEdge    = OldLeft;
  983.                                     ThisEntry->TopEdge    = OldTop;
  984.                                     ThisEntry->Width    = OldWidth;
  985.                                     ThisEntry->Height    = OldHeight;
  986.                                     ThisEntry->CurrentX    = OldCurrentX;
  987.                                     ThisEntry->CurrentY    = OldCurrentY;
  988.                                     ThisEntry->Flags    = OldFlags;
  989.                                     ThisEntry->ViewMode    = OldViewMode;
  990.                                 }
  991.                             }
  992.                             else
  993.                                 Found = FALSE;
  994.                         }
  995.                     }
  996.                 }
  997.                 else
  998.                     UnLock(CheckLock);
  999.  
  1000.                 ReleaseSemaphore(&FIconSema->FIconSema);
  1001.             }
  1002.         }
  1003.     }
  1004.  
  1005.     if(VolName)
  1006.         FreeMem(VolName, 130);
  1007.  
  1008.     if(DevName)
  1009.         FreeMem(DevName, 130);
  1010.  
  1011.  
  1012.     if(!Found)
  1013.         RetVal = OldLock(Name, Mode, DOSBase);
  1014.  
  1015.     return(RetVal);
  1016. }
  1017.  
  1018.  
  1019.  
  1020.  
  1021.  
  1022.  
  1023. /**********************************************************************/
  1024. /*               Store icons position of the info file                */
  1025. /**********************************************************************/
  1026. static BOOL StoreIconPos(struct DiskObject *Icon)
  1027. {
  1028.     struct    FileLock    *Dir;
  1029.     struct    DosList        *DList;
  1030.     struct    VolEntry    *ThisEntry;
  1031.     char            *VolName;
  1032.     BPTR            MyLock,
  1033.                 CheckLock;
  1034.     BOOL            Found        = FALSE,
  1035.                 RetVal        = FALSE,
  1036.                 Created        = FALSE,
  1037.                 IsReadOnly    = FALSE;
  1038.  
  1039.  
  1040.  
  1041.         // Get our semaphore
  1042.  
  1043.     ObtainSemaphore(&FIconSema->FIconSema);
  1044.  
  1045.  
  1046.         // Get buffers
  1047.  
  1048.     if((VolName = AllocMem(130, MEMF_CLEAR)))
  1049.     {
  1050.             // Switch to current dir
  1051.  
  1052.         MyLock    = CurrentDir(NULL);
  1053.         Dir    = (struct FileLock *)BADDR(MyLock);
  1054.         DList    = (struct DosList *)BADDR(Dir->fl_Volume);
  1055.  
  1056.             // Get name of volume inserted
  1057.  
  1058.         strncpy(VolName, ((char *)BADDR(DList->dol_Name) + 1), *((char *)BADDR(DList->dol_Name)));
  1059.  
  1060.             // Reset current dir
  1061.  
  1062.         CurrentDir(MyLock);
  1063.  
  1064.             // Get Name of Device
  1065.  
  1066.         if((DList = LockDosList(LDF_DEVICES|LDF_READ)))
  1067.         {
  1068.             while((DList = NextDosEntry(DList, LDF_DEVICES|LDF_READ)))
  1069.             {
  1070.                 if(Dir->fl_Task == DList->dol_Task)
  1071.                 {
  1072.                     struct    InfoData    __aligned    InfoData;
  1073.  
  1074.                         // Get information about drive
  1075.  
  1076.                     if(DoPkt(Dir->fl_Task, ACTION_DISK_INFO, MKBADDR(&InfoData), NULL, NULL, NULL, NULL))
  1077.                     {
  1078.                             // Is drive write protected?
  1079.  
  1080.                         if(InfoData.id_DiskState == ID_WRITE_PROTECTED)
  1081.                             IsReadOnly    = TRUE;
  1082.                     }
  1083.                 }
  1084.             }
  1085.             UnLockDosList(LDF_DEVICES|LDF_READ);
  1086.         }
  1087.  
  1088.  
  1089.  
  1090.             // Really to load from ROOT ???
  1091.  
  1092.         if(!(CheckLock = ParentDir(MyLock)))
  1093.         {
  1094.                 // Do we have patches waiting ???
  1095.  
  1096.             if(!IsListEmpty(&FIconSema->VolumeList))
  1097.             {
  1098.                 ThisEntry = (struct VolEntry *)FIconSema->VolumeList.lh_Head;
  1099.  
  1100.                 do
  1101.                 {
  1102.                         // This one to patch ???
  1103.  
  1104.                     if(ThisEntry->Link.ln_Type == LDF_VOLUMES && !MyStrCmp(ThisEntry->VolName, VolName))
  1105.                         Found = TRUE;
  1106.  
  1107.                     else
  1108.                         ThisEntry = (struct VolEntry *)ThisEntry->Link.ln_Succ;
  1109.  
  1110.                 } while(!Found && ThisEntry->Link.ln_Succ);
  1111.             }
  1112.  
  1113.  
  1114.                 // Object to be patched found? If not, create new entry (VOLUME)
  1115.  
  1116.             if(!Found)
  1117.             {
  1118.                     // Clear pointer
  1119.  
  1120.                 ThisEntry    = NULL;
  1121.  
  1122.                     // Device really is READONLY?
  1123.  
  1124.                 if(IsReadOnly)
  1125.                 {
  1126.                         // Try to create new entry
  1127.  
  1128.                     if((ThisEntry = AllocVecPool(FIconSema, sizeof(struct VolEntry))))
  1129.                     {
  1130.                             // Fill in structure and set flag
  1131.  
  1132.                         ThisEntry->Link.ln_Name    = ThisEntry->VolName;
  1133.                         ThisEntry->Link.ln_Type    = LDF_VOLUMES;
  1134.                         strcpy(ThisEntry->VolName, VolName);
  1135.                         Created        = TRUE;
  1136.                     }
  1137.                 }
  1138.             }
  1139.  
  1140.                 // Got an entry?
  1141.  
  1142.             if(ThisEntry)
  1143.             {
  1144.                 struct    Screen    *WBScreen    = LockPubScreen("Workbench");
  1145.  
  1146.                     // Got screen?
  1147.  
  1148.                 if(WBScreen)
  1149.                 {
  1150.                         // Created new entry? Add to list
  1151.  
  1152.                     if(Created)
  1153.                         AddHead(&FIconSema->VolumeList, (struct Node *)ThisEntry);
  1154.  
  1155.                         // Set vars for icon placement
  1156.  
  1157.                     ThisEntry->Left        = Icon->do_CurrentX;
  1158.                     ThisEntry->Top        = Icon->do_CurrentY + WBScreen->BarHeight + 1;
  1159.                     ThisEntry->IconPos    = MODE_USE;
  1160.                     RetVal            = TRUE;
  1161.  
  1162.                         // Unlock screen
  1163.  
  1164.                     UnlockPubScreen(NULL, WBScreen);
  1165.                 }
  1166.                 else
  1167.                 {
  1168.                         // Failure and created entry?
  1169.                         // Free memory associated
  1170.  
  1171.                     if(Created)
  1172.                         FreeVecPool(FIconSema, ThisEntry);
  1173.                 }
  1174.             }
  1175.         }
  1176.         else
  1177.             UnLock(CheckLock);
  1178.     }
  1179.  
  1180.     if(VolName)
  1181.         FreeMem(VolName, 130);
  1182.  
  1183.         // Release that fine semaphore
  1184.  
  1185.     ReleaseSemaphore(&FIconSema->FIconSema);
  1186.  
  1187.     return(RetVal);
  1188. }
  1189.  
  1190.  
  1191.  
  1192.  
  1193.  
  1194.  
  1195.  
  1196.  
  1197.  
  1198. /**********************************************************************/
  1199. /*                           Open libraries                           */
  1200. /**********************************************************************/
  1201. static BOOL OpenAll(void)
  1202. {
  1203.     if(!(IntuitionBase = (struct IntuitionBase *)OpenLibrary("intuition.library", 37)))
  1204.     {
  1205.         DisplayError(ERR_OPEN, (ULONG)"intuition.library", 37);
  1206.         return(FALSE);
  1207.     }
  1208.  
  1209.     if(!(DOSBase = (struct DosLibrary *)OpenLibrary("dos.library", 37)))
  1210.     {
  1211.         DisplayError(ERR_OPEN, (ULONG)"dos.library", 37);
  1212.         return(FALSE);
  1213.     }
  1214.  
  1215.     if(!(IconBase = OpenLibrary("icon.library", 37)))
  1216.     {
  1217.         DisplayError(ERR_OPEN, (ULONG)"icon.library", 37);
  1218.         return(FALSE);
  1219.     }
  1220.  
  1221.     if(!(UtilityBase = OpenLibrary("utility.library", 37)))
  1222.     {
  1223.         DisplayError(ERR_OPEN, (ULONG)"utility.library", 37);
  1224.         return(FALSE);
  1225.     }
  1226.  
  1227.     if(!(IFFParseBase = OpenLibrary("iffparse.library", 37)))
  1228.     {
  1229.         DisplayError(ERR_OPEN, (ULONG)"iffparse.library", 37);
  1230.         return(FALSE);
  1231.     }
  1232.  
  1233.     if(!(AslBase = OpenLibrary("asl.library", 36)))
  1234.     {
  1235.         DisplayError(ERR_OPEN, (ULONG)"asl.library", 36);
  1236.         return(FALSE);
  1237.     }
  1238.  
  1239.     if(!(WorkbenchBase = OpenLibrary("workbench.library", 37)))
  1240.     {
  1241.         DisplayError(ERR_OPEN, (ULONG)"workbench.library", 37);
  1242.         return(FALSE);
  1243.     }
  1244.  
  1245.     return(TRUE);
  1246. }
  1247.  
  1248.  
  1249.  
  1250.  
  1251.  
  1252.  
  1253.  
  1254.  
  1255. /**********************************************************************/
  1256. /*                          Close libraries                           */
  1257. /**********************************************************************/
  1258. static void CloseAll(void)
  1259. {
  1260.     CloseLibrary(WorkbenchBase);
  1261.     CloseLibrary(AslBase);
  1262.     CloseLibrary(IFFParseBase);
  1263.     CloseLibrary(UtilityBase);
  1264.     CloseLibrary(IconBase);
  1265.     CloseLibrary((struct Library *)DOSBase);
  1266.     CloseLibrary((struct Library *)IntuitionBase);
  1267. }
  1268.  
  1269.  
  1270.  
  1271.  
  1272. /**********************************************************************/
  1273. /*                     AppIcon support functions                      */
  1274. /**********************************************************************/
  1275.  
  1276. /**********************************************************************/
  1277. /*                      New AddAppIconA function                      */
  1278. /**********************************************************************/
  1279. ULONG    __stdargs CallOldAddAppIconA(ULONG ID, ULONG UserData, char *Text, struct MsgPort *Port, struct FileLock *FLock, struct DiskObject *DObj, struct TagItem *TagList, struct Library *WorkbenchBase, APTR Vector);
  1280. ULONG    __saveds __stdargs MyAddAppIconAFunc(ULONG ID, ULONG UserData, char *Text, struct MsgPort *Port, struct FileLock *FLock, struct DiskObject *DObj, struct TagItem *TagList, struct Library *WorkbenchBase)
  1281. {
  1282.     struct    VolEntry    *ThisEntry    = (struct VolEntry *)FIconSema->AppIconList.lh_Head;
  1283.     struct    DiskObject    *NewObj        = NULL;
  1284.     char            *TaskName,
  1285.                 *Pattern    = NULL;
  1286.     ULONG            *AIcon;
  1287.     BOOL            Found        = FALSE;
  1288.  
  1289.         // Allocate buffers
  1290.  
  1291.     if((TaskName = AllocVec(258, MEMF_CLEAR)) && (Pattern = AllocVec(514, MEMF_CLEAR)))
  1292.     {
  1293.         struct    Process        *MyProc        = (struct Process *)SysBase->ThisTask;
  1294.         char            *MyName        = MyProc->pr_Task.tc_Node.ln_Name;
  1295.         UWORD            NameLen        = strlen(MyName);
  1296.  
  1297.             // Task a process?
  1298.  
  1299.         if(MyProc->pr_Task.tc_Node.ln_Type == NT_PROCESS && MyProc->pr_CLI)
  1300.         {
  1301.             struct    CommandLineInterface    *CLI = BADDR(MyProc->pr_CLI);
  1302.  
  1303.             if(CLI->cli_Module && CLI->cli_CommandName)
  1304.             {
  1305.                 char    *Dummy    = BADDR(CLI->cli_CommandName);
  1306.  
  1307.                 NameLen        = *Dummy++;
  1308.                 MyName        = Dummy;
  1309.             }
  1310.         }
  1311.  
  1312.             // Copy name of task who called us
  1313.  
  1314.         setmem(TaskName, 256, 0);
  1315.         strncpy(TaskName, MyName, (NameLen >= 256 ? 256 : NameLen));
  1316.  
  1317.             // See to find an entry of our list
  1318.  
  1319.         while(ThisEntry->Link.ln_Succ && !Found)
  1320.         {
  1321.                 // Convert pattern
  1322.  
  1323.             if(ParsePatternNoCase(ThisEntry->VolName, Pattern, 512) != -1)
  1324.             {
  1325.                     // This is our task?
  1326.  
  1327.                 if(MatchPatternNoCase(Pattern, TaskName))
  1328.                 {
  1329.                     Found    = TRUE;
  1330.                     break;
  1331.                 }
  1332.             }
  1333.  
  1334.             if(!Found)
  1335.                 ThisEntry    = (struct VolEntry *)ThisEntry->Link.ln_Succ;
  1336.         }
  1337.  
  1338.             // Got an entry?
  1339.  
  1340.         if(Found)
  1341.         {
  1342.             LONG    OldX    = DObj->do_CurrentX,
  1343.                 OldY    = DObj->do_CurrentY;
  1344.  
  1345.  
  1346.             if(ThisEntry->UseAlt == MODE_USE)
  1347.             {
  1348.                 char        *EndPtr    = strstr(ThisEntry->IconName, ".info");
  1349.  
  1350.                 setmem(Pattern, 512, 0);
  1351.                 strncpy(Pattern, ThisEntry->IconName, (EndPtr ? (EndPtr - ThisEntry->IconName) : strlen(ThisEntry->IconName)));
  1352.  
  1353.                 if((NewObj = GetDiskObject(Pattern)))
  1354.                 {
  1355.                     NewObj->do_CurrentX    = OldX;
  1356.                     NewObj->do_CurrentY    = OldY;
  1357.  
  1358.                     DObj    = NewObj;
  1359.                 }
  1360.                 else
  1361.                 {
  1362.                     // No new icon, no patch
  1363.  
  1364.                     Found    = FALSE;
  1365.                 }
  1366.             }
  1367.  
  1368.             if(Found && (ThisEntry->IconPos == MODE_USE))
  1369.             {
  1370.                 struct    Screen    *WBScreen    = LockPubScreen("Workbench");
  1371.                 LONG        Left        = ThisEntry->Left,
  1372.                         Top        = ThisEntry->Top;
  1373.  
  1374.                 if(WBScreen)
  1375.                 {
  1376.                     DObj->do_CurrentX = (Left < 0 ? WBScreen->Width + Left : Left);
  1377.                     DObj->do_CurrentY = (Top < 0 ? WBScreen->Height + Top - WBScreen->BarHeight - 1 : Top - WBScreen->BarHeight - 1);
  1378.  
  1379.                     UnlockPubScreen(NULL, WBScreen);
  1380.                 }
  1381.             }
  1382.         }
  1383.     }
  1384.  
  1385.     if(TaskName)
  1386.         FreeVec(TaskName);
  1387.  
  1388.     if(Pattern)
  1389.         FreeVec(Pattern);
  1390.  
  1391.         // Call old function
  1392.  
  1393.     if((AIcon = (ULONG *)CallOldAddAppIconA(ID, UserData, Text, Port, FLock, DObj, TagList, WorkbenchBase, OldAddAppIconA)))
  1394.     {
  1395.             // Successful patch? Store address of created AppIcon
  1396.  
  1397.         if(Found)
  1398.         {
  1399.             ThisEntry->AppIconAdr    = (struct AppIcon *)AIcon;
  1400.             ThisEntry->DObj        = NewObj;
  1401.  
  1402.             if(NewObj)
  1403.                 NumAppIcons++;
  1404.         }
  1405.     }
  1406.     else
  1407.     {
  1408.             // Failed to create new AppIcon, delete our Icon,
  1409.             // if present
  1410.  
  1411.         if(NewObj)
  1412.             FreeDiskObject(NewObj);
  1413.     }
  1414.  
  1415.     return((ULONG)AIcon);
  1416. }
  1417.  
  1418.  
  1419.  
  1420.  
  1421.  
  1422. /**********************************************************************/
  1423. /*                     New RemoveAppicon function                     */
  1424. /**********************************************************************/
  1425. static ULONG    __saveds __asm    MyRemoveAppIcon(register __a0 struct AppIcon *AIcon, register __a6 struct Library *WorkbenchBase)
  1426. {
  1427.     struct    VolEntry    *ThisEntry    = (struct VolEntry *)FIconSema->AppIconList.lh_Head;
  1428.     ULONG            RetVal;
  1429.  
  1430.         // Remove AppIcon
  1431.  
  1432.     RetVal    = OldRemoveAppIcon(AIcon, WorkbenchBase);
  1433.  
  1434.         // This is one of ours?
  1435.  
  1436.     while(ThisEntry->Link.ln_Succ)
  1437.     {
  1438.         if(ThisEntry->AppIconAdr == AIcon)
  1439.         {
  1440.             if(ThisEntry->DObj)
  1441.             {
  1442.                 FreeDiskObject(ThisEntry->DObj);
  1443.                 NumAppIcons--;
  1444.             }
  1445.  
  1446.             ThisEntry->AppIconAdr    = NULL;
  1447.             ThisEntry->DObj        = NULL;
  1448.  
  1449.             break;
  1450.         }
  1451.  
  1452.         ThisEntry    = (struct VolEntry *)ThisEntry->Link.ln_Succ;
  1453.     }
  1454.  
  1455.     return(RetVal);
  1456. }
  1457.  
  1458.  
  1459.  
  1460. /**********************************************************************/
  1461. /*       Now include the LoadRoutine and the VolumeList routine       */
  1462. /**********************************************************************/
  1463. #include    "LoadPrefs.h"
  1464. #include    "VolList.h"
  1465. #include    "Error.h"
  1466. #include    "Rendezvous.h"
  1467. #include    "CheckToolTypes.h"
  1468. #include    "PoolVec.h"
  1469.